var mescroll1,
    mescroll2,
    mescroll3,
    mescroll4,
    mescroll5,
    mescroll6,
    mescroll7,
    mescroll8,
    mescroll9,
    mescroll10,
    mescroll11,
    mescroll12,
    mescroll13,
    mescroll14,
    mescroll15,
    mescroll16,
    mescroll17,
    mescroll18,
    mescroll19,
    mescroll20;

/*下拉刷新的回调 */
function downCallback() {
    var pullUp = $('#mainMatch .swiper-slide').eq(navIndex).attr('data-uflag');
    console.log(pullUp)

    if (pullUp == 'true') {
        getMatchIndex(2,'up');

    } else {
        mescroll0.endErr();
        mescroll1.endErr();
        mescroll2.endErr();
        mescroll3.endErr();
        mescroll4.endErr();
        mescroll5.endErr();
        mescroll6.endErr();
        mescroll7.endErr();
        mescroll8.endErr();
        mescroll9.endErr();
        mescroll10.endErr();
        mescroll11.endErr();
        mescroll12.endErr();
        mescroll13.endErr();
        mescroll14.endErr();
        mescroll15.endErr();
        mescroll16.endErr();
        mescroll17.endErr();
        mescroll18.endErr();
        mescroll19.endErr();
        mescroll20.endErr();
    }
}

/*上拉加载的回调 */
function upCallback() {
    var pullDown = $('#mainMatch .swiper-slide').eq(navIndex).attr('data-dflag');

    if (pullDown == 'true') {
        getMatchIndex(3,'down');

    } else {
        mescroll0.endErr();
        mescroll1.endErr();
        mescroll2.endErr();
        mescroll3.endErr();
        mescroll4.endErr();
        mescroll5.endErr();
        mescroll6.endErr();
        mescroll7.endErr();
        mescroll8.endErr();
        mescroll9.endErr();
        mescroll10.endErr();
        mescroll11.endErr();
        mescroll12.endErr();
        mescroll13.endErr();
        mescroll14.endErr();
        mescroll15.endErr();
        mescroll16.endErr();
        mescroll17.endErr();
        mescroll18.endErr();
        mescroll19.endErr();
        mescroll20.endErr();
    }
}
//创建MeScroll对象
var mescroll0 = new MeScroll("mescroll0", {
    down: {
        auto: false, //是否在初始化完毕之后自动执行下拉回调callback; 默认true
        callback: downCallback //下拉刷新的回调
    },
    up: {
        auto: false, //是否在初始化时以上拉加载的方式自动加载第一页数据; 默认false
        isBounce: true, //此处禁止ios回弹,解析(务必认真阅读,特别是最后一点): http://www.mescroll.com/qa.html#q10// 若为false ,页面上其他地方的滑动都滑不动
        callback: upCallback, //上拉回调,此处可简写; 相当于 callback: function (page) { upCallback(page); }
        /*toTop:{ //配置回到顶部按钮
            src : "../res/img/mescroll-totop.png", //默认滚动到1000px显示,可配置offset修改
            //offset : 1000
        }*/
        lazyLoad: {
            use: true, // 是否开启懒加载,默认false
            attr: 'imgurl', // 网络地址的属性名 (图片加载成功会移除该属性): <img imgurl='网络图  src='占位图''/>
            showClass: 'mescroll-lazy-in', // 图片加载成功的显示动画: 渐变显示,参见mescroll.css
            delay: 200, // 列表滚动的过程中每500ms检查一次图片是否在可视区域,如果在可视区域则加载图片
            offset: 500 // 超出可视区域200px的图片仍可触发懒加载,目的是提前加载部分图片
        }
    }
});



function loadMescroll() {


    mescroll1 = new MeScroll("mescroll1", {
        down: {
            auto: false, //是否在初始化完毕之后自动执行下拉回调callback; 默认true
            callback: downCallback //下拉刷新的回调
        },
        up: {
            auto: false, //是否在初始化时以上拉加载的方式自动加载第一页数据; 默认false
            isBounce: true, //此处禁止ios回弹,解析(务必认真阅读,特别是最后一点): http://www.mescroll.com/qa.html#q10// 若为false ,页面上其他地方的滑动都滑不动
            callback: upCallback, //上拉回调,此处可简写; 相当于 callback: function (page) { upCallback(page); }
            /*toTop:{ //配置回到顶部按钮
                src : "../res/img/mescroll-totop.png", //默认滚动到1000px显示,可配置offset修改
                //offset : 1000
            }*/
            lazyLoad: {
                use: true, // 是否开启懒加载,默认false
                attr: 'imgurl', // 网络地址的属性名 (图片加载成功会移除该属性): <img imgurl='网络图  src='占位图''/>
                showClass: 'mescroll-lazy-in', // 图片加载成功的显示动画: 渐变显示,参见mescroll.css
                delay: 200, // 列表滚动的过程中每500ms检查一次图片是否在可视区域,如果在可视区域则加载图片
                offset: 500 // 超出可视区域200px的图片仍可触发懒加载,目的是提前加载部分图片
            }
        }
    });

    mescroll2 = new MeScroll("mescroll2", {
        down: {
            auto: false, //是否在初始化完毕之后自动执行下拉回调callback; 默认true
            callback: downCallback //下拉刷新的回调
        },
        up: {
            auto: false, //是否在初始化时以上拉加载的方式自动加载第一页数据; 默认false
            isBounce: true, //此处禁止ios回弹,解析(务必认真阅读,特别是最后一点): http://www.mescroll.com/qa.html#q10// 若为false ,页面上其他地方的滑动都滑不动
            callback: upCallback, //上拉回调,此处可简写; 相当于 callback: function (page) { upCallback(page); }
            /*toTop:{ //配置回到顶部按钮
                src : "../res/img/mescroll-totop.png", //默认滚动到1000px显示,可配置offset修改
                //offset : 1000
            }*/
            lazyLoad: {
                use: true, // 是否开启懒加载,默认false
                attr: 'imgurl', // 网络地址的属性名 (图片加载成功会移除该属性): <img imgurl='网络图  src='占位图''/>
                showClass: 'mescroll-lazy-in', // 图片加载成功的显示动画: 渐变显示,参见mescroll.css
                delay: 200, // 列表滚动的过程中每500ms检查一次图片是否在可视区域,如果在可视区域则加载图片
                offset: 500 // 超出可视区域200px的图片仍可触发懒加载,目的是提前加载部分图片
            }
        }
    });
    mescroll3 = new MeScroll("mescroll3", {
        down: {
            auto: false, //是否在初始化完毕之后自动执行下拉回调callback; 默认true
            callback: downCallback //下拉刷新的回调
        },
        up: {
            auto: false, //是否在初始化时以上拉加载的方式自动加载第一页数据; 默认false
            isBounce: true, //此处禁止ios回弹,解析(务必认真阅读,特别是最后一点): http://www.mescroll.com/qa.html#q10// 若为false ,页面上其他地方的滑动都滑不动
            callback: upCallback, //上拉回调,此处可简写; 相当于 callback: function (page) { upCallback(page); }
            /*toTop:{ //配置回到顶部按钮
                src : "../res/img/mescroll-totop.png", //默认滚动到1000px显示,可配置offset修改
                //offset : 1000
            }*/
            lazyLoad: {
                use: true, // 是否开启懒加载,默认false
                attr: 'imgurl', // 网络地址的属性名 (图片加载成功会移除该属性): <img imgurl='网络图  src='占位图''/>
                showClass: 'mescroll-lazy-in', // 图片加载成功的显示动画: 渐变显示,参见mescroll.css
                delay: 200, // 列表滚动的过程中每500ms检查一次图片是否在可视区域,如果在可视区域则加载图片
                offset: 500 // 超出可视区域200px的图片仍可触发懒加载,目的是提前加载部分图片
            }
        }
    });
    mescroll4 = new MeScroll("mescroll4", {
        down: {
            auto: false, //是否在初始化完毕之后自动执行下拉回调callback; 默认true
            callback: downCallback //下拉刷新的回调
        },
        up: {
            auto: false, //是否在初始化时以上拉加载的方式自动加载第一页数据; 默认false
            isBounce: true, //此处禁止ios回弹,解析(务必认真阅读,特别是最后一点): http://www.mescroll.com/qa.html#q10// 若为false ,页面上其他地方的滑动都滑不动
            callback: upCallback, //上拉回调,此处可简写; 相当于 callback: function (page) { upCallback(page); }
            /*toTop:{ //配置回到顶部按钮
                src : "../res/img/mescroll-totop.png", //默认滚动到1000px显示,可配置offset修改
                //offset : 1000
            }*/
            lazyLoad: {
                use: true, // 是否开启懒加载,默认false
                attr: 'imgurl', // 网络地址的属性名 (图片加载成功会移除该属性): <img imgurl='网络图  src='占位图''/>
                showClass: 'mescroll-lazy-in', // 图片加载成功的显示动画: 渐变显示,参见mescroll.css
                delay: 200, // 列表滚动的过程中每500ms检查一次图片是否在可视区域,如果在可视区域则加载图片
                offset: 500 // 超出可视区域200px的图片仍可触发懒加载,目的是提前加载部分图片
            }
        }
    });
    mescroll5 = new MeScroll("mescroll5", {
        down: {
            auto: false, //是否在初始化完毕之后自动执行下拉回调callback; 默认true
            callback: downCallback //下拉刷新的回调
        },
        up: {
            auto: false, //是否在初始化时以上拉加载的方式自动加载第一页数据; 默认false
            isBounce: true, //此处禁止ios回弹,解析(务必认真阅读,特别是最后一点): http://www.mescroll.com/qa.html#q10// 若为false ,页面上其他地方的滑动都滑不动
            callback: upCallback, //上拉回调,此处可简写; 相当于 callback: function (page) { upCallback(page); }
            /*toTop:{ //配置回到顶部按钮
                src : "../res/img/mescroll-totop.png", //默认滚动到1000px显示,可配置offset修改
                //offset : 1000
            }*/
            lazyLoad: {
                use: true, // 是否开启懒加载,默认false
                attr: 'imgurl', // 网络地址的属性名 (图片加载成功会移除该属性): <img imgurl='网络图  src='占位图''/>
                showClass: 'mescroll-lazy-in', // 图片加载成功的显示动画: 渐变显示,参见mescroll.css
                delay: 200, // 列表滚动的过程中每500ms检查一次图片是否在可视区域,如果在可视区域则加载图片
                offset: 500 // 超出可视区域200px的图片仍可触发懒加载,目的是提前加载部分图片
            }
        }
    });
    mescroll6 = new MeScroll("mescroll6", {
        down: {
            auto: false, //是否在初始化完毕之后自动执行下拉回调callback; 默认true
            callback: downCallback //下拉刷新的回调
        },
        up: {
            auto: false, //是否在初始化时以上拉加载的方式自动加载第一页数据; 默认false
            isBounce: true, //此处禁止ios回弹,解析(务必认真阅读,特别是最后一点): http://www.mescroll.com/qa.html#q10// 若为false ,页面上其他地方的滑动都滑不动
            callback: upCallback, //上拉回调,此处可简写; 相当于 callback: function (page) { upCallback(page); }
            /*toTop:{ //配置回到顶部按钮
                src : "../res/img/mescroll-totop.png", //默认滚动到1000px显示,可配置offset修改
                //offset : 1000
            }*/
            lazyLoad: {
                use: true, // 是否开启懒加载,默认false
                attr: 'imgurl', // 网络地址的属性名 (图片加载成功会移除该属性): <img imgurl='网络图  src='占位图''/>
                showClass: 'mescroll-lazy-in', // 图片加载成功的显示动画: 渐变显示,参见mescroll.css
                delay: 200, // 列表滚动的过程中每500ms检查一次图片是否在可视区域,如果在可视区域则加载图片
                offset: 500 // 超出可视区域200px的图片仍可触发懒加载,目的是提前加载部分图片
            }
        }
    });
    mescroll7 = new MeScroll("mescroll7", {
        down: {
            auto: false, //是否在初始化完毕之后自动执行下拉回调callback; 默认true
            callback: downCallback //下拉刷新的回调
        },
        up: {
            auto: false, //是否在初始化时以上拉加载的方式自动加载第一页数据; 默认false
            isBounce: true, //此处禁止ios回弹,解析(务必认真阅读,特别是最后一点): http://www.mescroll.com/qa.html#q10// 若为false ,页面上其他地方的滑动都滑不动
            callback: upCallback, //上拉回调,此处可简写; 相当于 callback: function (page) { upCallback(page); }
            /*toTop:{ //配置回到顶部按钮
                src : "../res/img/mescroll-totop.png", //默认滚动到1000px显示,可配置offset修改
                //offset : 1000
            }*/
            lazyLoad: {
                use: true, // 是否开启懒加载,默认false
                attr: 'imgurl', // 网络地址的属性名 (图片加载成功会移除该属性): <img imgurl='网络图  src='占位图''/>
                showClass: 'mescroll-lazy-in', // 图片加载成功的显示动画: 渐变显示,参见mescroll.css
                delay: 200, // 列表滚动的过程中每500ms检查一次图片是否在可视区域,如果在可视区域则加载图片
                offset: 500 // 超出可视区域200px的图片仍可触发懒加载,目的是提前加载部分图片
            }
        }
    });
    mescroll8 = new MeScroll("mescroll8", {
        down: {
            auto: false, //是否在初始化完毕之后自动执行下拉回调callback; 默认true
            callback: downCallback //下拉刷新的回调
        },
        up: {
            auto: false, //是否在初始化时以上拉加载的方式自动加载第一页数据; 默认false
            isBounce: true, //此处禁止ios回弹,解析(务必认真阅读,特别是最后一点): http://www.mescroll.com/qa.html#q10// 若为false ,页面上其他地方的滑动都滑不动
            callback: upCallback, //上拉回调,此处可简写; 相当于 callback: function (page) { upCallback(page); }
            /*toTop:{ //配置回到顶部按钮
                src : "../res/img/mescroll-totop.png", //默认滚动到1000px显示,可配置offset修改
                //offset : 1000
            }*/
            lazyLoad: {
                use: true, // 是否开启懒加载,默认false
                attr: 'imgurl', // 网络地址的属性名 (图片加载成功会移除该属性): <img imgurl='网络图  src='占位图''/>
                showClass: 'mescroll-lazy-in', // 图片加载成功的显示动画: 渐变显示,参见mescroll.css
                delay: 200, // 列表滚动的过程中每500ms检查一次图片是否在可视区域,如果在可视区域则加载图片
                offset: 500 // 超出可视区域200px的图片仍可触发懒加载,目的是提前加载部分图片
            }
        }
    });
    mescroll9 = new MeScroll("mescroll9", {
        down: {
            auto: false, //是否在初始化完毕之后自动执行下拉回调callback; 默认true
            callback: downCallback //下拉刷新的回调
        },
        up: {
            auto: false, //是否在初始化时以上拉加载的方式自动加载第一页数据; 默认false
            isBounce: true, //此处禁止ios回弹,解析(务必认真阅读,特别是最后一点): http://www.mescroll.com/qa.html#q10// 若为false ,页面上其他地方的滑动都滑不动
            callback: upCallback, //上拉回调,此处可简写; 相当于 callback: function (page) { upCallback(page); }
            /*toTop:{ //配置回到顶部按钮
                src : "../res/img/mescroll-totop.png", //默认滚动到1000px显示,可配置offset修改
                //offset : 1000
            }*/
            lazyLoad: {
                use: true, // 是否开启懒加载,默认false
                attr: 'imgurl', // 网络地址的属性名 (图片加载成功会移除该属性): <img imgurl='网络图  src='占位图''/>
                showClass: 'mescroll-lazy-in', // 图片加载成功的显示动画: 渐变显示,参见mescroll.css
                delay: 200, // 列表滚动的过程中每500ms检查一次图片是否在可视区域,如果在可视区域则加载图片
                offset: 500 // 超出可视区域200px的图片仍可触发懒加载,目的是提前加载部分图片
            }
        }
    });
    mescroll10 = new MeScroll("mescroll10", {
        down: {
            auto: false, //是否在初始化完毕之后自动执行下拉回调callback; 默认true
            callback: downCallback //下拉刷新的回调
        },
        up: {
            auto: false, //是否在初始化时以上拉加载的方式自动加载第一页数据; 默认false
            isBounce: true, //此处禁止ios回弹,解析(务必认真阅读,特别是最后一点): http://www.mescroll.com/qa.html#q10// 若为false ,页面上其他地方的滑动都滑不动
            callback: upCallback, //上拉回调,此处可简写; 相当于 callback: function (page) { upCallback(page); }
            /*toTop:{ //配置回到顶部按钮
                src : "../res/img/mescroll-totop.png", //默认滚动到1000px显示,可配置offset修改
                //offset : 1000
            }*/
            lazyLoad: {
                use: true, // 是否开启懒加载,默认false
                attr: 'imgurl', // 网络地址的属性名 (图片加载成功会移除该属性): <img imgurl='网络图  src='占位图''/>
                showClass: 'mescroll-lazy-in', // 图片加载成功的显示动画: 渐变显示,参见mescroll.css
                delay: 200, // 列表滚动的过程中每500ms检查一次图片是否在可视区域,如果在可视区域则加载图片
                offset: 500 // 超出可视区域200px的图片仍可触发懒加载,目的是提前加载部分图片
            }
        }
    });
    mescroll11 = new MeScroll("mescroll11", {
        down: {
            auto: false, //是否在初始化完毕之后自动执行下拉回调callback; 默认true
            callback: downCallback //下拉刷新的回调
        },
        up: {
            auto: false, //是否在初始化时以上拉加载的方式自动加载第一页数据; 默认false
            isBounce: true, //此处禁止ios回弹,解析(务必认真阅读,特别是最后一点): http://www.mescroll.com/qa.html#q10// 若为false ,页面上其他地方的滑动都滑不动
            callback: upCallback, //上拉回调,此处可简写; 相当于 callback: function (page) { upCallback(page); }
            /*toTop:{ //配置回到顶部按钮
                src : "../res/img/mescroll-totop.png", //默认滚动到1000px显示,可配置offset修改
                //offset : 1000
            }*/
            lazyLoad: {
                use: true, // 是否开启懒加载,默认false
                attr: 'imgurl', // 网络地址的属性名 (图片加载成功会移除该属性): <img imgurl='网络图  src='占位图''/>
                showClass: 'mescroll-lazy-in', // 图片加载成功的显示动画: 渐变显示,参见mescroll.css
                delay: 200, // 列表滚动的过程中每500ms检查一次图片是否在可视区域,如果在可视区域则加载图片
                offset: 500 // 超出可视区域200px的图片仍可触发懒加载,目的是提前加载部分图片
            }
        }
    });
    mescroll12 = new MeScroll("mescroll12", {
        down: {
            auto: false, //是否在初始化完毕之后自动执行下拉回调callback; 默认true
            callback: downCallback //下拉刷新的回调
        },
        up: {
            auto: false, //是否在初始化时以上拉加载的方式自动加载第一页数据; 默认false
            isBounce: true, //此处禁止ios回弹,解析(务必认真阅读,特别是最后一点): http://www.mescroll.com/qa.html#q10// 若为false ,页面上其他地方的滑动都滑不动
            callback: upCallback, //上拉回调,此处可简写; 相当于 callback: function (page) { upCallback(page); }
            /*toTop:{ //配置回到顶部按钮
                src : "../res/img/mescroll-totop.png", //默认滚动到1000px显示,可配置offset修改
                //offset : 1000
            }*/
            lazyLoad: {
                use: true, // 是否开启懒加载,默认false
                attr: 'imgurl', // 网络地址的属性名 (图片加载成功会移除该属性): <img imgurl='网络图  src='占位图''/>
                showClass: 'mescroll-lazy-in', // 图片加载成功的显示动画: 渐变显示,参见mescroll.css
                delay: 200, // 列表滚动的过程中每500ms检查一次图片是否在可视区域,如果在可视区域则加载图片
                offset: 500 // 超出可视区域200px的图片仍可触发懒加载,目的是提前加载部分图片
            }
        }
    });
    mescroll13 = new MeScroll("mescroll13", {
        down: {
            auto: false, //是否在初始化完毕之后自动执行下拉回调callback; 默认true
            callback: downCallback //下拉刷新的回调
        },
        up: {
            auto: false, //是否在初始化时以上拉加载的方式自动加载第一页数据; 默认false
            isBounce: true, //此处禁止ios回弹,解析(务必认真阅读,特别是最后一点): http://www.mescroll.com/qa.html#q10// 若为false ,页面上其他地方的滑动都滑不动
            callback: upCallback, //上拉回调,此处可简写; 相当于 callback: function (page) { upCallback(page); }
            /*toTop:{ //配置回到顶部按钮
                src : "../res/img/mescroll-totop.png", //默认滚动到1000px显示,可配置offset修改
                //offset : 1000
            }*/
            lazyLoad: {
                use: true, // 是否开启懒加载,默认false
                attr: 'imgurl', // 网络地址的属性名 (图片加载成功会移除该属性): <img imgurl='网络图  src='占位图''/>
                showClass: 'mescroll-lazy-in', // 图片加载成功的显示动画: 渐变显示,参见mescroll.css
                delay: 200, // 列表滚动的过程中每500ms检查一次图片是否在可视区域,如果在可视区域则加载图片
                offset: 500 // 超出可视区域200px的图片仍可触发懒加载,目的是提前加载部分图片
            }
        }
    });
    mescroll14 = new MeScroll("mescroll14", {
        down: {
            auto: false, //是否在初始化完毕之后自动执行下拉回调callback; 默认true
            callback: downCallback //下拉刷新的回调
        },
        up: {
            auto: false, //是否在初始化时以上拉加载的方式自动加载第一页数据; 默认false
            isBounce: true, //此处禁止ios回弹,解析(务必认真阅读,特别是最后一点): http://www.mescroll.com/qa.html#q10// 若为false ,页面上其他地方的滑动都滑不动
            callback: upCallback, //上拉回调,此处可简写; 相当于 callback: function (page) { upCallback(page); }
            /*toTop:{ //配置回到顶部按钮
                src : "../res/img/mescroll-totop.png", //默认滚动到1000px显示,可配置offset修改
                //offset : 1000
            }*/
            lazyLoad: {
                use: true, // 是否开启懒加载,默认false
                attr: 'imgurl', // 网络地址的属性名 (图片加载成功会移除该属性): <img imgurl='网络图  src='占位图''/>
                showClass: 'mescroll-lazy-in', // 图片加载成功的显示动画: 渐变显示,参见mescroll.css
                delay: 200, // 列表滚动的过程中每500ms检查一次图片是否在可视区域,如果在可视区域则加载图片
                offset: 500 // 超出可视区域200px的图片仍可触发懒加载,目的是提前加载部分图片
            }
        }
    });
    mescroll15 = new MeScroll("mescroll15", {
        down: {
            auto: false, //是否在初始化完毕之后自动执行下拉回调callback; 默认true
            callback: downCallback //下拉刷新的回调
        },
        up: {
            auto: false, //是否在初始化时以上拉加载的方式自动加载第一页数据; 默认false
            isBounce: true, //此处禁止ios回弹,解析(务必认真阅读,特别是最后一点): http://www.mescroll.com/qa.html#q10// 若为false ,页面上其他地方的滑动都滑不动
            callback: upCallback, //上拉回调,此处可简写; 相当于 callback: function (page) { upCallback(page); }
            /*toTop:{ //配置回到顶部按钮
                src : "../res/img/mescroll-totop.png", //默认滚动到1000px显示,可配置offset修改
                //offset : 1000
            }*/
            lazyLoad: {
                use: true, // 是否开启懒加载,默认false
                attr: 'imgurl', // 网络地址的属性名 (图片加载成功会移除该属性): <img imgurl='网络图  src='占位图''/>
                showClass: 'mescroll-lazy-in', // 图片加载成功的显示动画: 渐变显示,参见mescroll.css
                delay: 200, // 列表滚动的过程中每500ms检查一次图片是否在可视区域,如果在可视区域则加载图片
                offset: 500 // 超出可视区域200px的图片仍可触发懒加载,目的是提前加载部分图片
            }
        }
    });
    mescroll16 = new MeScroll("mescroll16", {
        down: {
            auto: false, //是否在初始化完毕之后自动执行下拉回调callback; 默认true
            callback: downCallback //下拉刷新的回调
        },
        up: {
            auto: false, //是否在初始化时以上拉加载的方式自动加载第一页数据; 默认false
            isBounce: true, //此处禁止ios回弹,解析(务必认真阅读,特别是最后一点): http://www.mescroll.com/qa.html#q10// 若为false ,页面上其他地方的滑动都滑不动
            callback: upCallback, //上拉回调,此处可简写; 相当于 callback: function (page) { upCallback(page); }
            /*toTop:{ //配置回到顶部按钮
                src : "../res/img/mescroll-totop.png", //默认滚动到1000px显示,可配置offset修改
                //offset : 1000
            }*/
            lazyLoad: {
                use: true, // 是否开启懒加载,默认false
                attr: 'imgurl', // 网络地址的属性名 (图片加载成功会移除该属性): <img imgurl='网络图  src='占位图''/>
                showClass: 'mescroll-lazy-in', // 图片加载成功的显示动画: 渐变显示,参见mescroll.css
                delay: 200, // 列表滚动的过程中每500ms检查一次图片是否在可视区域,如果在可视区域则加载图片
                offset: 500 // 超出可视区域200px的图片仍可触发懒加载,目的是提前加载部分图片
            }
        }
    });
    mescroll17 = new MeScroll("mescroll17", {
        down: {
            auto: false, //是否在初始化完毕之后自动执行下拉回调callback; 默认true
            callback: downCallback //下拉刷新的回调
        },
        up: {
            auto: false, //是否在初始化时以上拉加载的方式自动加载第一页数据; 默认false
            isBounce: true, //此处禁止ios回弹,解析(务必认真阅读,特别是最后一点): http://www.mescroll.com/qa.html#q10// 若为false ,页面上其他地方的滑动都滑不动
            callback: upCallback, //上拉回调,此处可简写; 相当于 callback: function (page) { upCallback(page); }
            /*toTop:{ //配置回到顶部按钮
                src : "../res/img/mescroll-totop.png", //默认滚动到1000px显示,可配置offset修改
                //offset : 1000
            }*/
            lazyLoad: {
                use: true, // 是否开启懒加载,默认false
                attr: 'imgurl', // 网络地址的属性名 (图片加载成功会移除该属性): <img imgurl='网络图  src='占位图''/>
                showClass: 'mescroll-lazy-in', // 图片加载成功的显示动画: 渐变显示,参见mescroll.css
                delay: 200, // 列表滚动的过程中每500ms检查一次图片是否在可视区域,如果在可视区域则加载图片
                offset: 500 // 超出可视区域200px的图片仍可触发懒加载,目的是提前加载部分图片
            }
        }
    });
    mescroll18 = new MeScroll("mescroll18", {
        down: {
            auto: false, //是否在初始化完毕之后自动执行下拉回调callback; 默认true
            callback: downCallback //下拉刷新的回调
        },
        up: {
            auto: false, //是否在初始化时以上拉加载的方式自动加载第一页数据; 默认false
            isBounce: true, //此处禁止ios回弹,解析(务必认真阅读,特别是最后一点): http://www.mescroll.com/qa.html#q10// 若为false ,页面上其他地方的滑动都滑不动
            callback: upCallback, //上拉回调,此处可简写; 相当于 callback: function (page) { upCallback(page); }
            /*toTop:{ //配置回到顶部按钮
                src : "../res/img/mescroll-totop.png", //默认滚动到1000px显示,可配置offset修改
                //offset : 1000
            }*/
            lazyLoad: {
                use: true, // 是否开启懒加载,默认false
                attr: 'imgurl', // 网络地址的属性名 (图片加载成功会移除该属性): <img imgurl='网络图  src='占位图''/>
                showClass: 'mescroll-lazy-in', // 图片加载成功的显示动画: 渐变显示,参见mescroll.css
                delay: 200, // 列表滚动的过程中每500ms检查一次图片是否在可视区域,如果在可视区域则加载图片
                offset: 500 // 超出可视区域200px的图片仍可触发懒加载,目的是提前加载部分图片
            }
        }
    });
    mescroll19 = new MeScroll("mescroll19", {
        down: {
            auto: false, //是否在初始化完毕之后自动执行下拉回调callback; 默认true
            callback: downCallback //下拉刷新的回调
        },
        up: {
            auto: false, //是否在初始化时以上拉加载的方式自动加载第一页数据; 默认false
            isBounce: true, //此处禁止ios回弹,解析(务必认真阅读,特别是最后一点): http://www.mescroll.com/qa.html#q10// 若为false ,页面上其他地方的滑动都滑不动
            callback: upCallback, //上拉回调,此处可简写; 相当于 callback: function (page) { upCallback(page); }
            /*toTop:{ //配置回到顶部按钮
                src : "../res/img/mescroll-totop.png", //默认滚动到1000px显示,可配置offset修改
                //offset : 1000
            }*/
            lazyLoad: {
                use: true, // 是否开启懒加载,默认false
                attr: 'imgurl', // 网络地址的属性名 (图片加载成功会移除该属性): <img imgurl='网络图  src='占位图''/>
                showClass: 'mescroll-lazy-in', // 图片加载成功的显示动画: 渐变显示,参见mescroll.css
                delay: 200, // 列表滚动的过程中每500ms检查一次图片是否在可视区域,如果在可视区域则加载图片
                offset: 500 // 超出可视区域200px的图片仍可触发懒加载,目的是提前加载部分图片
            }
        }
    });
    mescroll20 = new MeScroll("mescroll20", {
        down: {
            auto: false, //是否在初始化完毕之后自动执行下拉回调callback; 默认true
            callback: downCallback //下拉刷新的回调
        },
        up: {
            auto: false, //是否在初始化时以上拉加载的方式自动加载第一页数据; 默认false
            isBounce: true, //此处禁止ios回弹,解析(务必认真阅读,特别是最后一点): http://www.mescroll.com/qa.html#q10// 若为false ,页面上其他地方的滑动都滑不动
            callback: upCallback, //上拉回调,此处可简写; 相当于 callback: function (page) { upCallback(page); }
            /*toTop:{ //配置回到顶部按钮
                src : "../res/img/mescroll-totop.png", //默认滚动到1000px显示,可配置offset修改
                //offset : 1000
            }*/
            lazyLoad: {
                use: true, // 是否开启懒加载,默认false
                attr: 'imgurl', // 网络地址的属性名 (图片加载成功会移除该属性): <img imgurl='网络图  src='占位图''/>
                showClass: 'mescroll-lazy-in', // 图片加载成功的显示动画: 渐变显示,参见mescroll.css
                delay: 200, // 列表滚动的过程中每500ms检查一次图片是否在可视区域,如果在可视区域则加载图片
                offset: 500 // 超出可视区域200px的图片仍可触发懒加载,目的是提前加载部分图片
            }
        }
    });
}


function endErr(index) {
    // mescroll0.lazyLoad();//图片懒加载，数据加载之后使当前可视区域的图片显示出来

    if(index == 0){
        mescroll0.endErr();

    }else if(index == 1){
        mescroll1.endErr();

    }else if(index == 2){
        mescroll2.endErr();

    }else if(index == 3){
        mescroll3.endErr();

    }else if(index == 4){
        mescroll4.endErr();

    }else if(index == 5){
        mescroll5.endErr();

    }else if(index == 6){
        mescroll6.endErr();

    }else if(index == 7){
        mescroll7.endErr();

    }else if(index == 8){
        mescroll8.endErr();

    }else if(index == 9){
        mescroll9.endErr();

    }else if(index == 10){
        mescroll10.endErr();

    }else if(index == 11){
        mescroll11.endErr();

    }else if(index == 12){
        mescroll12.endErr();

    }else if(index == 13){
        mescroll13.endErr();

    }else if(index == 14){
        mescroll14.endErr();

    }else if(index == 15){
        mescroll15.endErr();

    }else if(index == 16){
        mescroll16.endErr();

    }else if(index == 17){
        mescroll17.endErr();

    }else if(index == 18){
        mescroll18.endErr();

    }else if(index == 19){
        mescroll19.endErr();

    }else if(index == 20){
        mescroll20.endErr();

    }



}
